import i18n from '../i18n';
import Constant from './Constant';

export function splitBySecondLastSlash(path, newGroupId) {
  console.log(path, newGroupId, 'splitBySecondLastSlash');
  const regex = /sticker_group_\d+/g; // 匹配旧的标识符模式
  // 直接替换整个匹配项
  return path.replace(regex, newGroupId);
}

// 定义一个函数来提取文件名
export const extractFileName = path => {
  // 使用正则表达式匹配文件名（不包括路径和后缀）
  const match = path.match(/([^/]*)\.[^.]+$/);
  // 如果匹配成功，返回匹配的第一个捕获组（即文件名），否则返回空字符串
  return match ? match[1] : '';
};

export function incrementFileName(fileName) {
  console.log(fileName, 'splitBySecondLastSlash');

  // 正则表达式，匹配前缀、可选的紧跟下划线的数字（捕获组）和扩展名
  const regex = /(.*?)_(?:(\d+))?(\..*)?$/;
  const match = fileName.match(regex);

  if (match) {
    // 提取前缀、数字和扩展名
    const prefix = match[1];
    const numberStr = match[2] || '0'; // 如果没有数字，则默认为'0'
    const extension = match[3] || '';

    // 将数字转换为整数并递增
    const number = parseInt(numberStr, 10);
    const newNumber = number + 1;

    // 构造新的文件名
    return `${prefix}_${newNumber}${extension}`;
  } else {
    // 如果不匹配（非常罕见的情况），则返回原始文件名加1
    let str = fileName.split('.');
    return `${str[0]}1.${str[1]}`;
  }
}
export function findStrNum(str1, str2) {
  // 找出两个字符串长度不同或字符不同的位置
  let diffIndex = -1;
  for (let i = 0; i < Math.min(str1.length, str2.length); i++) {
    if (str1[i] !== str2[i]) {
      diffIndex = i;
      break;
    }
  }
  // 如果没有找到不同，但字符串长度不同，则不同部分在较长字符串的末尾
  if (diffIndex === -1 && str1.length !== str2.length) {
    diffIndex = Math.max(str1.length, str2.length);
  }

  // 提取不同部分（可能是一个字符串的末尾部分或整个字符串，如果完全不同）
  let diffPart = '';
  if (diffIndex !== -1 && diffIndex < str1.length) {
    diffPart = str1.slice(diffIndex);
  } else if (diffIndex !== -1 && diffIndex < str2.length) {
    diffPart = str2.slice(diffIndex);
  } else {
    // 如果到这里，说明两个字符串完全不同，你可以根据需要处理
    // 例如，你可以返回 false 或抛出错误
    return false; // 或者你可以决定如何处理这种情况
  }

  // 检查不同部分是否是数字
  const numericRegex = /^\d+$/; // 匹配整个字符串都是数字的正则表达式
  return numericRegex.test(diffPart);
}

// 自动生成贴纸的名称后缀
const stickerNameTail = "_sticker";

/// 获取创建贴纸时自动生成的贴纸名 
export const findNextAutoCreateStickerName = (
  arr,//  当前贴纸库的所有贴纸数据
  stickerGroupName, // 当前贴纸库的名称
  extractor = item => item.name) => {
  console.log("findNextAutoCreateStickerName stickerGroupName", stickerGroupName);
  let baseStr = stickerGroupName + stickerNameTail;
  // 需要判断是否大于150，大于要截取贴纸库名
  if(baseStr.length > Constant.maxInputNum) {
    var cutLength = baseStr.length - Constant.maxInputNum;
    stickerGroupName = stickerGroupName.slice(0, stickerGroupName.length - cutLength);
    baseStr = stickerGroupName + stickerNameTail;
  }
  
  console.log("findNextAutoCreateStickerName arr", arr);
  console.log("findNextAutoCreateStickerName baseStr", baseStr);
  if (
    !Array.isArray(arr) ||
    arr.length === 0 ||
    !arr.some(item => item.name === baseStr)
  ) {
    return baseStr; // 如果基础字符串不存在于数组中，直接返回基础字符串
  }
  // 提取所有已存在的、以基础字符串开头的项的数字部分，并转换为数组
  const existingNumbers = arr
    .map(item => {
      const extractedStr = extractor(item).trim();
      if(extractedStr === baseStr) {
        return 0;
      }
      const match = extractedStr.match(/\(\d+\)$/);
      if (match) {
        // 获取里面的数字
        const matchNum = match[0].match(/\d+/);
        return matchNum ? parseInt(matchNum[0], 10) : null;
      } else {
        return null;
      }

    })
    .filter(num => num !== null)
    .sort((a, b) => a - b); // 排序以确保我们可以找到连续的未使用数字
  console.log("findNextAutoCreateStickerName existingNumbers:", existingNumbers);
  if (!existingNumbers || existingNumbers.length <= 0) {
    return baseStr;
  }
  // 找到第一个未使用的数字
  for (let i = 1; i <= 10000; i++) {
    // 假设我们不会使用超过1000的数字作为后缀
    if (!existingNumbers.includes(i)) {
      let tailStr = `(${i})`;
      let newName = baseStr + tailStr;
      if (newName.length > Constant.maxInputNum) {
        var cutLength = newName.length - Constant.maxInputNum;
        return findNextAutoCreateStickerName(
          arr,
          stickerGroupName.slice(0, stickerGroupName.length - 1),
          extractor);
      }

      return `${baseStr}(${i})`;
    }
  }
  return baseStr + "(-1)"
}

export const findNextEm = (arr, baseStr, extractor = item => item.name) => {
  if (
    !Array.isArray(arr) ||
    arr.length === 0 ||
    !arr.some(item => item.name === baseStr)
  ) {
    return baseStr; // 如果基础字符串不存在于数组中，直接返回基础字符串
  }
  // 提取所有已存在的、以基础字符串开头的项的数字部分，并转换为数组
  const existingNumbers = arr
    .map(item => {
      const extractedStr = extractor(item).trim();
      const match = extractedStr.match(/\(\d+\)$/);
      if(match) {
        // 获取里面的数字
        const matchNum = match[0].match(/\d+/);
        return matchNum ? parseInt(matchNum[0], 10) : null;
      } else {
        return null;
      }
      
    })
    .filter(num => num !== null)
    .sort((a, b) => a - b); // 排序以确保我们可以找到连续的未使用数字
    console.log("findNextEm existingNumbers:", existingNumbers);
    if(!existingNumbers || existingNumbers.length <= 0) {
      return baseStr;
    }

  // 找到第一个未使用的数字
  for (let i = 1; i <= 10000; i++) {
    // 假设我们不会使用超过1000的数字作为后缀
    if (!existingNumbers.includes(i)) {
      return `${baseStr}(${i})`;
    }
  }
  return baseStr + ' ' + baseStr;
};
export const findNext2Em = (arr, baseStr) => {
  if (
    !Array.isArray(arr) ||
    arr.length === 0 ||
    !arr.some(item => item.name === baseStr)
  ) {
    return baseStr; // 如果基础字符串不存在于数组中，直接返回基础字符串
  }

  // 遍历数字，尝试生成不重复的新名称
  for (let i = 1; i <= 100; i++) {
    let newName = `${baseStr}(${i})`;
    // 使用 some 检查数组中是否已存在该名称
    if (!arr.some(item => item.name === newName)) {
      return newName; // 如果名称唯一，返回新名称
    }
  }
  return `${baseStr}(${101})`;
};

// 排序函数
export function sortByName(arr, ascending = true) {
  return arr.sort((a, b) => {
    if (ascending) {
      return a.name.localeCompare(b.name);
    } else {
      return b.name.localeCompare(a.name);
    }
  });
}

export function extractFileInfo(filePath) {
  // 使用正则表达式从路径中提取文件名（不包括扩展名）
  const nameMatch = filePath.match(/([^\/]+)(?=\.[^\/]+$)/);
  const name = nameMatch ? nameMatch[0] : '未知名称'; // 如果没有匹配到，则使用'未知名称'

  return {
    name: name,
    path: filePath,
  };
}
export function incrementIfDecimal(num) {
  // 检查输入是否为小数
  if (Number.isInteger(num)) {
    // 如果是整数，直接返回
    return num;
  } else {
    // 如果不是整数（即有小数部分），则四舍五入到最近的整数后加1
    return Math.round(num) + 1;
  }
}
export const splitWhole = input => {
  // 查找最后一个空格的索引位置
  const lastIndex = input.lastIndexOf(' ');

  // 如果没有找到空格，则直接返回整个字符串
  if (lastIndex === -1) {
    return input;
  }

  // 提取第二部分并去除首尾空格
  const secondPartTrimmed = input.slice(lastIndex + 1).trim();

  // 检查第二部分是否是数字（这里使用简单的正则表达式检查是否仅包含数字）
  const isSecondPartNumber = /^\d+$/.test(secondPartTrimmed);

  // 如果第二部分是数字，则返回第一部分（也去除首尾空格）
  if (isSecondPartNumber) {
    return input.slice(0, lastIndex).trimEnd();
  }

  // 如果第二部分不是数字，则返回整个字符串
  return input;
};
const groupArray = (array, title, size) => {
  const result = [];
  for (let i = 0; i < array.length; i += size) {
    const chunk = array.slice(i, i + size);
    result.push({title, data: chunk});
  }
  return result;
};
export const chunkArray = (arr, chunkSize) => {
  return arr.reduce((acc, curr, idx) => {
    const chunkIndex = Math.floor(idx / chunkSize);
    if (!acc[chunkIndex]) {
      acc[chunkIndex] = [];
    }
    acc[chunkIndex].push(curr);
    return acc;
  }, []);
};

// 解析内置贴纸名的json数
export const parseNameJson = jsonStr => {
  try {
    let lang = i18n.language;
    let obj = JSON.parse(jsonStr);
    if (lang === 'zh-CN') {
      return obj.zh_CN;
    } else if (lang === 'zh-TW') {
      return obj.zh_TW;
    } else if (lang.includes('ja')) {
      return obj.ja;
    } else if (lang.includes('en')) {
      return obj.en;
    }
  } catch (e) {
    return jsonStr;
  }
};

export const RegExpArr = {
  special: /[/<>*?|\\:`\"].*/,
  specialEmoji:
    /(?:[\u2700-\u27bf]|(?:\ud83c[\udde6-\uddff]){2}|[\ud800-\udbff][\udc00-\udfff])[\ufe0e\ufe0f]?(?:[\u0300-\u036f\ufe20-\ufe23\u20d0-\u20f0]|\ud83c[\udffb-\udfff])?(?:\u200d(?:[^\ud800-\udfff]|(?:\ud83c[\udde6-\uddff]){2}|[\ud800-\udbff][\udc00-\udfff])[\ufe0e\ufe0f]?(?:[\u0300-\u036f\ufe20-\ufe23\u20d0-\u20f0]|\ud83c[\udffb-\udfff])?)*/,
};

export const checkArray = (array, chunkSize) => {
  const result = [];
  for (let i = 0; i < array.length; i += chunkSize) {
    const chunk = array.slice(i, i + chunkSize);
    result.push(chunk);
  }
  return result;
};
